﻿SeadragonJSBrowser = function() {
    /// <field name="UNKNOWN">Any browser that's not one of the below.</field>
    /// <field name="IE">Microsoft Internet Explorer.</field>
    /// <field name="FIREFOX">Mozilla Firefox.</field>
    /// <field name="SAFARI">Apple Safari.</field>
    /// <field name="OPERA">Opera.</field>
    /// <field name="CHROME">Google Chrome.</field>
}

SeadragonJSBrowser.prototype =
{
    UNKNOWN: null,
    IE: null,
    FIREFOX: null,
    SAFARI: null,
    OPERA: null,
    CHROME: null
}
﻿SeadragonJSButton = function(tooltip, srcRest, srcGroup, srcHover, srcDown, onPress, onRelease, onClick, onEnter, onExit) {
    /// <summary>Creates a button with the given tooltip, state images and event handlers.</summary>
    /// <param name="tooltip"></param>
    /// <param name="srcRest">Image of the button</param>
    /// <param name="srcGroup"></param>
    /// <param name="srcHover">Mouse over image of the button</param>
    /// <param name="onPress">OnPress associated event of the button</param>
    /// <param name="onRelease">OnRelease associated event of the button</param>
    /// <param name="onClick">onClick associated event of the button</param>
    /// <param name="onEnter">onEnter associated event of the button</param>
    /// <param name="onExit">onExit associated event of the button</param>
    /// <field name="elmt" type="string">HTML Element. The element representing this button. This property is a semantic alias; re-assigning it has no effect, but modifying it does.</field>
    /// <returns type="Object"></returns>
}

SeadragonJSButton.prototype =
{
    elmt: null,

    notifyGroupEnter: function() {
        /// <summary>Notifies this button that the mouse has entered a button group that contains this button.</summary>
    },

    notifyGroupExit: function() {
        /// <summary>Notifies this button that the mouse has exited a button group that contains this button.</summary>
    }
}
﻿SeadragonJSButtonGroup = function(buttons) {
    /// <summary>Creates a ButtonGroup for the given list of buttons.</summary>
    /// <param name="buttons" type="Array">Array of Button</param>
    /// <field name="elmt" type="string">HTML Element. The element representing this button. This property is a semantic alias; re-assigning it has no effect, but modifying it does.</field>
    /// <returns type="Object"></returns>
}

SeadragonJSButtonGroup.prototype =
{
    elmt: null,

    emulateEnter: function() {
        /// <summary>Emulates the mouse entering this button group, so that each contained button is activated.</summary>
    },

    emulateExit: function() {
        /// <summary>Emulates the mouse exiting this button group, so that each contained button is de-activated.</summary>
    }
}
﻿SeadragonJSConfig = function() {
    /// <summary>This static class defines configuration values that can be tweaked to customize Seadragon behavior. Unless otherwise noted, a change to any value will result in immediately visible changes to all viewers.</summary>
    /// <field name="debugMode" type="Boolean">WhethThe desired number of frames per second. Default is 60.</field>
    /// <field name="framesPerSecond" type="Number">Whether messages should be logged and fail-fast behavior should be provided. Default is false. </field>
    /// <field name="animationTime" type="Number">The amount of time in seconds that animations should last. Default is 1.5.</field>
    /// <field name="blendTime" type="Number">The amount of time in seconds that new tiles take to blend from transparent to opaque. Default is 0.5.</field>
    /// <field name="alwaysBlend" type="Boolean">Whether tiles should always blend in and out, not just when they're first loaded. Default is false.</field>
    /// <field name="autoHideControls" type="Boolean">Whether controls should get automatically hidden when the user's mouse is off the viewer and the image has stopped animating. Default is true.</field>
    /// <field name="immediateRender" type="Boolean">Whether the most appropriate tiles should always be rendered first, before any lower-res tiles are rendered. This loses the "sharpening" effect and instead creates a very visible "tiling" effect. Default is false. </field>
    /// <field name="minZoomDimension" type="Number">The minimum size (in screen pixels) of either dimension that can result from zooming out. Default is 16.</field>
    /// <field name="maxZoomPixelRatio" type="Number">The maximum pixel ratio (screen pixel to content pixel) that can result from zooming in. Default is 4.</field>
    /// <field name="visibilityRatio" type="Number">The minimum portion of the viewport that must show visible content in both dimensions. Default is 0.1.</field>
    /// <field name="springStiffness" type="Number">Determines how sharply the springs used for animations move. Default is 5.0.</field>
    /// <field name="imageLoaderLimit" type="Number">The maximum number of concurrent image downloads that can be performed by each viewer. Default is 2.</field>
    /// <field name="clickTimeThreshold" type="Number">The maximum number of milliseconds that can pass between a mousedown and a mouseup for the action to still be considered a "quick" click. Default is 200.</field>
    /// <field name="clickDistThreshold" type="Number">The maximum number of pixels the mouse can move between a mousedown and a mouseup for the action to still be considered a "quick" click. Default is 5.</field>
    /// <field name="zoomPerClick" type="Number">The factor by which images should zoom when clicked on. Default is 2.</field>
    /// <field name="zoomPerScroll" type="Number">The factor by which images should zoom over each second when the zoom buttons are held down. Default is 2.</field>
    /// <field name="proxyUrl" type="Number">The URL to prefix before any AJAX requests to overcome browser cross-site restrictions. The URL should be of the form "some/proxy.aspx?site=", so that the target site URL is passed as a GET parameter to the proxy. This URL can be absolute or relative, but must be on the same domain as the HTML page. If relative, it must be relative to the HTML page. Default is null.</field>
    /// <field name="imagePath" type="Number">The path for all UI images. This can be absolute or relative. If relative, it must be relative to the HTML page. A change to this value will only affect new viewers. Default is "img/".</field>

}

SeadragonJSConfig.debugMode = null;
SeadragonJSConfig.framesPerSecond = null;
SeadragonJSConfig.animationTime = null;
SeadragonJSConfig.blendTime = null;
SeadragonJSConfig.alwaysBlend = null;
SeadragonJSConfig.autoHideControls = null;
SeadragonJSConfig.immediateRender = null;
SeadragonJSConfig.minZoomDimension = null;
SeadragonJSConfig.maxZoomPixelRatio = null;
SeadragonJSConfig.visibilityRatio = null;
SeadragonJSConfig.springStiffness = null;
SeadragonJSConfig.imageLoaderLimit = null;
SeadragonJSConfig.clickTimeThreshold = null;
SeadragonJSConfig.clickDistThreshold = null;
SeadragonJSConfig.zoomPerClick = null;
SeadragonJSConfig.zoomPerScroll = null;
SeadragonJSConfig.zoomPerSecond = null;
SeadragonJSConfig.proxyUrl = null;
SeadragonJSConfig.imagePath = null;
﻿SeadragonJSControlAnchor = function() {
    /// <field name="NONE">The control is not anchored; it must be absolutely positioned through CSS.</field>
    /// <field name="TOP_LEFT">The control is anchored to the top-left corner of the viewer.</field>
    /// <field name="TOP_RIGHT">The control is anchored to the top-right corner of the viewer.</field>
    /// <field name="BOTTOM_RIGHT">The control is anchored to the bottom-right corner of the viewer.</field>
    /// <field name="BOTTOM_LEFT">The control is anchored to the bottom-left corner of the viewer.</field>
}

SeadragonJSControlAnchor.prototype =
{
    NONE: null,
    TOP_LEFT: null,
    TOP_RIGHT: null,
    BOTTOM_RIGHT: null,
    BOTTOM_LEFT: null
}
﻿SeadragonJSDebug = function() {
    /// <summary>STATIC CLASS</summary>
}

SeadragonJSDebug.log = function(msg, important) {
    /// <summary>If Seadragon.Config.debugMode is true, writes the given message to the browser's Javascript console. If the browser doesn't provide a Javascript console and the optional important parameter is true, alerts the message instead.</summary>
    /// <param name="msg" type="string">Message to write on log</param>
    /// <param name="important" type="Boolean">Wether important message or not. If true, an alert window is displayed.</param>
}

SeadragonJSDebug.error = function(msg, exception) {
    /// <summary>Writes the given message to the browser's Javascript console as an error message. If the browser doesn't provide a Javascript console, alerts the message if Seadragon.Config.debugMode is true. In either case, if Seadragon.Config.debugMode is true, provides fail-fast behavior by throwing an error to crash Seadragon. If an exception is given, the thrown error is the same exception, otherwise it is a new Error object with the given message.</summary>
    /// <param name="msg" type="string">Message to write on log</param>
    /// <param name="exception"></param>
}

SeadragonJSDebug.fail = function(msg) {
    /// <summary>Alerts to the user the Seadragon.Strings "Errors.Failure" message, and throws an error to crash Seadragon.</summary>
    /// <param name="msg" type="string">Message to display</param>
}
﻿SeadragonJSDisplayRect = function(x, y, width, height, minLevel, maxLevel) {
    /// <summary>Creates a DisplayRect for the given point, size and levels. Note that minLevel and maxLevel are both inclusive.</summary>
    /// <param name="x" type="Number"></param>
    /// <param name="y" type="Number"></param>
    /// <param name="width" type="Number"></param>
    /// <param name="height" type="Number"></param>
    /// <param name="minLevel" type="Number"></param>
    /// <param name="maxLevel" type="Number"></param>
    /// <field name="minLevel" type="Number"></field>
    /// <field name="maxLevel" type="Number"></field>
    /// <returns type="Object"></returns>
}

SeadragonJSDisplayRect.prototype =
{
    minLevel: null,
    maxLevel: null
}
﻿SeadragonJSDrawer = function(source, viewport, elmt) {
    /// <summary>Creates a button with the given tooltip, state images and event handlers.</summary>
    /// <param name="tooltip"></param>
    /// <param name="srcRest">Image of the button</param>
    /// <param name="srcGroup"></param>
    /// <field name="elmt" type="string">HTML Element. The HTML element inside which the content is rendered. This is the same HTML element that is passed into the constructor. The specifics of this element and its children are unspecified and implementation-dependent.</field>
    /// <field name="profiler" type="SeadragonJSProfiler">A Seadragon.Profiler instance that is profiling each update.</field>
    /// <returns type="Object"></returns>
}

SeadragonJSDrawer.prototype =
{
    elmt: null,
    profiler: null,

    addOverlay: function(elmt, rect) {
        /// <summary>Adds the given HTML element as an overlay to the content if it has not been added before. This overlay will scale with the content; the element's size will always match the given Seadragon.Rect, which must be in normalized coordinates (see Seadragon.Viewport for details).</summary>
        /// <param name="elmt"></param>
        /// <param name="rect"></param>
    },

    addOverlay: function(elmt, point, placement) {
        /// <summary>Adds the given HTML element as an overlay to the content if it has not been added before. This overlay will not scale with the content; its size will remain untouched. The overlay will be placed at the given Seadragon.Point, which must be a normalized coordinate (see Seadragon.Viewport for details).</summary>
        /// <param name="elmt"></param>
        /// <param name="point"></param>
        /// <param name="placement"> An optional Seadragon.OverlayPlacement value can be given that describes which part of the element is specifically placed at the given point. If none is given, the element is placed by its center.</param>
    },

    updateOverlay: function(elmt, rect) {
        /// <summary>Updates the given HTML element overlay to the given Seadragon.Rect. The overlay will scale with the content.</summary>
        /// <param name="elmt"></param>
        /// <param name="rect"></param>
    },

    updateOverlay: function(elmt, point, placement) {
        /// <summary>Updates the given HTML element overlay to the given Seadragon.Point. and optionally the given Seadragon.OverlayPlacement. If no placement is given, the element is placed by its center. The overlay will not scale with the content.</summary>
        /// <param name="elmt"></param>
        /// <param name="point"></param>
        /// <param name="placement"></param>
    },

    removeOverlay: function(elmt) {
        /// <summary>Removes the given HTML element overlay.</summary>
        /// <param name="elmt"></param>
    },

    clearOverlays: function() {
        /// <summary>Removes all HTML element overlays.</summary>
    },

    needsUpdate: function() {
        /// <summary>Returns true if the drawer needs an update since the last update.</summary>
        /// <returns type="Boolean"></returns>
    },

    reset: function() {
        /// <summary>Resets this drawer so that the content is re-drawn from scratch. Overlays are maintained, however.</summary>
    },

    update: function() {
        /// <summary>Updates the drawn content based on the viewport's current values.</summary>
    }

}
﻿SeadragonJSButton = function(width, height, tileSize, tileOverlap, tilesUrl, fileFormat, displayRects) {
    /// <summary>Creates a DziTileSource for a Deep Zoom Image having tiles of the given format at the given URL. If the image is sparse, the image's display rectangles should be given as a list of Seadragon.DisplayRect instances.</summary>
    /// <param name="width"></param>
    /// <param name="height"></param>
    /// <param name="tileSize"></param>
    /// <param name="tileOverlap"></param>
    /// <param name="tilesUrl"></param>
    /// <param name="fileFormat">The file format used by this Deep Zoom Image.</param>
    /// <param name="displayRects" optional="true">If this image is sparse, the Seadragon.DisplayRect instances given to the constructor, otherwise null.</param>
    /// <field name="fileFormat" type="string">The file format used by this Deep Zoom Image.</field>
    /// <field name="displayRects" type="string">If this image is sparse, the Seadragon.DisplayRect instances given to the constructor, otherwise null.</field>
    /// <returns type="Object"></returns>
}

SeadragonJSButton.prototype =
{
    fileFormat: null,
    displayRects: null,

    getTileUrl: function(level, x, y) {
        /// <summary>Returns the URL for the given tile.</summary>
        /// <param name="level"></param>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <returns type="string"></returns>
    },

    tileExists: function(level, x, y) {
        /// <summary>Returns true if the given tile exists and is part of the sparse image.</summary>
        /// <param name="level"></param>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <returns type="boolean"></returns>
    }
}

SeadragonJSButton.createFromXml = function(xmlUrl, xmlString, callback) {
    /// <summary>Creates a new Seadragon.DziTileSource from the XML file at the given URL. If the contents of the XML are given, the XML is not actually downloaded; otherwise, it is. (The location of the XML is needed in either case to determine the location of the tiles.)</summary>
    /// <param name="xmlUrl">XML File to download.</param>
    /// <param name="xmlString">If specified the XML file is not downloaded.</param>
    /// <param name="callback">If a callback function is given, the XML is loaded/parsed asynchronously, and the Seadragon.DziTileSource is passed as the sole parameter to the callback upon completion. Otherwise, the XML is loaded/parsed synchronously and the Seadragon.DziTileSource is returned by this method. If the XML fails to load/parse and a callback function was given, null is passed to the callback along with an optional error message as a second parameter. If the XML fails to load/parse and no callback function was given, an error is thrown.</param>
}
﻿SeadragonJSEventManager = function() {
    /// <summary>Creates a button with the given tooltip, state images and event handlers.</summary>
    /// <returns type="Object"></returns>
}

SeadragonJSEventManager.prototype =
{
    addListener: function(eventName, handler) {
        /// <summary>Adds the given handler function as a listener for the event with the given name.</summary>
        /// <param name="eventName"></param>
        /// <param name="handler"></param>        
    },

    removeListener: function(eventName, handler) {
        /// <summary>Removes the given handler function as a listener for the event with the given name.</summary>
        /// <param name="eventName"></param>
        /// <param name="srcRest"></param>
    },

    clearListeners: function(eventName) {
        /// <summary>Removes all listeners for the given event.</summary>
        /// <param name="eventName"></param>
    },

    trigger: function(eventName, parameters) {
        /// <summary>Triggers the event with the given name, optionally passing any additional arguments to the registered handler functions.</summary>
        /// <param name="eventName"></param>
        /// <param name="parameters"></param>        
    }
}
﻿SeadragonJSImageLoader = function() {
    /// <summary>Creates an ImageLoader with all slots empty.</summary>
    /// <returns type="Object"></returns>
}

SeadragonJSImageLoader.prototype =
{
    loadImage: function(src, callback) {
        /// <summary>If no image download slots are available, returns false immediately. Otherwise queues an asynchronous download of the image at the given URL and returns true. Once the download is complete, the given callback function is called with the image as the sole argument if the download succeeded, or null if the download failed.</summary>
        /// <param name="src">url of the image to download</param>
        /// <param name="callback">Once the download is complete, the given callback function is called with the image as the sole argument if the download succeeded, or null if the download failed.</param>
        /// <returns type="Boolean"></returns>        
    }
}
﻿Seadragon = function() {
    
}

Seadragon.prototype =
{
    
}
﻿SeadragonJSEventManager = function() {
    /// <summary>Creates a MouseTracker for the given HTML element. This MouseTracker is not initially tracking.</summary>
    /// <field name="target">HTML Element. The element that is getting tracked. This property is aliased; re-assigning it has no effect, but modifying it does.</field>
    /// <field name="enterHandler" type="Function">Handler function for the mouse entering the target element. Both buttonDownElmt and buttonDownAny are false if the mouse button is up. Otherwise, buttonDownAny is always true, and buttonDownElmt is true if the mouse was initially pressed inside the target element. (Note that buttonDownElmt implies buttonDownAny, but not necessarily the reverse.)</field>
    /// <field name="exitHandler" type="Function">Handler function for the mouse exiting the target element. Both buttonDownElmt and buttonDownAny are false if the mouse button is up. Otherwise, buttonDownAny is always true, and buttonDownElmt is true if the mouse was initially pressed inside the target element. (Note that buttonDownElmt implies buttonDownAny, but not necessarily the reverse.)</field>
    /// <field name="pressHandler" type="Function">Handler function for the mouse button being pressed inside the target element.</field>
    /// <field name="releaseHandler" type="Function">Handler function for the mouse button being released. Note that like regular "mouseup" events, this is always triggered when the mouse is released over the target element. However, unlike regular "mouseup" events, this is also always triggered when the corresponding "mousedown" event was fired inside the target element, even if the mouse is no longer over the element. insideElmtPress is true if the mouse was initially pressed inside the target element, and insideElmtRelease is true if this release occured inside the target element. (Note that at least one of insideElmtPress and insideElmtRelease will be true.)</field>
    /// <field name="clickHandler" type="Function">Handler function for the mouse button being clicked inside the target element. quick is true if, during the click, the mouse was neither moved a significant distance nor held down for a significant amount of time. shift is true if the shift key was pressed during the click. (The thresholds used to determine if the click was quick are defined in Seadragon.Config.)</field>
    /// <field name="dragHandler" type="Function">Handler function for the mouse being dragged. This is triggered only when the drag was initially begun inside the target element, but is triggered wherever the mouse may be at the moment. delta is a Seadragon.Point for the distance the mouse was dragged. shift is true if the shift key was pressed during the drag.</field>
    /// <field name="scrollHandler" type="Function">Handler function for the mouse wheel being scrolled inside the target element. scroll is the amount the mouse wheel was scrolled, normalized between -1 and 1. shift is true if the shift key was pressed during the scroll.</field>
    /// <returns type="Object"></returns>
}

SeadragonJSEventManager.prototype =
{
    target: null,
    enterHandler: null,
    exitHandler: null,
    pressHandler: null,
    releaseHandler: null,
    clickHandler: null,
    dragHandler: null,
    scrollHandler: null,

    isTracking: function() {
        /// <summary>Returns true if the target element is currently being tracked.</summary>
        /// <returns type="Boolean"></returns>           
    },

    setTracking: function(tracking) {
        /// <summary>Sets whether the target element should be tracked.</summary>
        /// <param name="tracking"></param>
    }
}
﻿SeadragonJSOverlayPlacement = function() {
    /// <field name="CENTER">The overlay's center is the point of placement.</field>
    /// <field name="TOP_LEFT">The overlay's top-left corner is the point of placement.</field>
    /// <field name="TOP">The center of the overlay's top edge is the point of placement.</field>
    /// <field name="TOP_RIGHT">The overlay's top-right corner is the point of placement.</field>
    /// <field name="RIGHT">The middle of the overlay's right edge is the point of placement.</field>
    /// <field name="BOTTOM_RIGHT">The overlay's bottom-right corner is the point of placement.</field>
    /// <field name="BOTTOM">The center of the overlay's bottom edge is the point of placement.</field>
    /// <field name="BOTTOM_LEFT">The overlay's bottom-left corner is the point of placement.</field>
    /// <field name="LEFT">The middle of the overlay's left edge is the point of placement.</field>
}

SeadragonJSOverlayPlacement.prototype =
{
    CENTER: null,
    TOP_LEFT: null,
    TOP: null,
    TOP_RIGHT: null,
    RIGHT: null,
    BOTTOM_RIGHT: null,
    BOTTOM: null,
    BOTTOM_LEFT: null,
    LEFT: null
}
﻿SeadragonJSPoint = function(x, y) {
    /// <summary>Creates a point at (x, y). A point is a 2-dimensional point.</summary>
    /// <param name="x"></param>
    /// <param name="y"></param>
    /// <field name="x" type="Number">The x value.</field>
    /// <field name="y" type="Number">The y value.</field>
    /// <returns type="Object"></returns>
}

SeadragonJSPoint.prototype =
{
    x: null,
    y: null,

    plus: function(point) {
        /// <summary>Returns a new Seadragon.Point, without modifying the current Seadragon.Point. Note that plus() and minus() take Seadragon.Points while times() and divide() take numbers.</summary>
        /// <param name="point"></param>
        /// <returns type="SeadragonJSPoint"></returns>
    },

    minus: function(point) {
        /// <summary>Returns a new Seadragon.Point, without modifying the current Seadragon.Point. Note that plus() and minus() take Seadragon.Points while times() and divide() take numbers.</summary>
        /// <param name="point"></param>
        /// <returns type="SeadragonJSPoint"></returns>
    },

    times: function(point) {
        /// <summary>Returns a new Seadragon.Point, without modifying the current Seadragon.Point. Note that plus() and minus() take Seadragon.Points while times() and divide() take numbers.</summary>
        /// <param name="point"></param>
        /// <returns type="SeadragonJSPoint"></returns>
    },

    divide: function(point) {
        /// <summary>Returns a new Seadragon.Point, without modifying the current Seadragon.Point. Note that plus() and minus() take Seadragon.Points while times() and divide() take numbers.</summary>
        /// <param name="point"></param>
        /// <returns type="SeadragonJSPoint"></returns>
    },

    apply: function(func) {
        /// <summary>Applies the given function to both x and y, and returns a new Seadragon.Point. An example function is Math.round.</summary>
        /// <param name="func"></param>
        /// <returns type="SeadragonJSPoint"></returns>
    },

    distanceTo: function(point) {
        /// <summary>Returns the distance from this point to the given point.</summary>
        /// <param name="point"></param>
        /// <returns type="Number"></returns>
    },

    equals: function(point) {
        /// <summary>Returns true if this point has the same x and y as the given point.</summary>
        /// <param name="point"></param>
        /// <returns type="Boolean"></returns>
    }
}
﻿SeadragonJSProfiler = function() {
    /// <summary>Creates a Profiler.</summary>
    /// <returns type="Object"></returns>
}

SeadragonJSProfiler.prototype =
{
    isMidUpdate: function() {
        /// <summary>Returns true if an update has begun but has not yet ended.</summary>
        /// <returns type="Boolean"></returns>
    },

    getNumUpdates: function() {
        /// <summary>Returns the number of updates that have been profiled.</summary>
        /// <returns type="Number"></returns>
    },

    //Update time accessors
    getAvgUpdateTime: function() {
        /// <summary>Returns the average length of each update.</summary>
        /// <returns type="Number"></returns>
    },

    getMinUpdateTime: function() {
        /// <summary>Returns the length of the shortest update.</summary>
        /// <returns type="Number"></returns>
    },

    getMaxUpdateTime: function() {
        /// <summary>Returns the length of the longest update.</summary>
        /// <returns type="Number"></returns>
    },

    //Idle Time Accessors
    getAvgIdleTime: function() {
        /// <summary>Returns the average length of each idle period between two updates.</summary>
        /// <returns type="Number"></returns>
    },

    getMinIdleTime: function() {
        /// <summary>Returns the length of the shortest idle period between two updates.</summary>
        /// <returns type="Number"></returns>
    },

    getMaxIdleTime: function() {
        /// <summary>Returns the length of the longest idle period between two updates.</summary>
        /// <returns type="Number"></returns>
    },

    //Idle Time Accessors
    beginUpdate: function() {
        /// <summary>Signals to the Profiler that an update has begun.</summary>
    },

    endUpdate: function() {
        /// <summary>Returns the length of the shortest idle period between two updates.</summary>
    },

    clearProfile: function() {
        /// <summary>Returns the length of the longest idle period between two updates.</summary>
    }
}
﻿SeadragonJSRect = function(x, y, width, height) {
    /// <summary>Creates a rectangle at (x, y) of size width x height.</summary>
    /// <param name="x"></param>
    /// <param name="y"></param>
    /// <field name="x" type="Number">The x value.</field>
    /// <field name="y" type="Number">The y value.</field>
    /// <field name="width" type="Number">The width of the rectangle.</field>
    /// <field name="height" type="Number">The height of the rectangle.</field>
    /// <returns type="Object"></returns>
}

SeadragonJSRect.prototype =
{
    x: null,
    y: null,
    width: null,
    width: null,

    getAspectRatio: function() {
        /// <summary>Returns this rectangle's aspect ratio (width / height).</summary>
        /// <returns type="Number"></returns>
    },

    getTopLeft: function() {
        /// <summary>Returns (x, y) as a Seadragon.Point.</summary>
        /// <returns type="SeadragonJSPoint"></returns>
    },

    getBottomRight: function() {
        /// <summary>Returns (x + width, y + height) as a Seadragon.Point.</summary>
        /// <returns type="SeadragonJSPoint"></returns>
    },

    getCenter: function() {
        /// <summary>Returns (x + 0.5 * width, y + 0.5 * height) as a Seadragon.Point.</summary>
        /// <returns type="SeadragonJSPoint"></returns>
    },

    getSize: function() {
        /// <summary>Returns (width, height) as a Seadragon.Point.</summary>
        /// <returns type="SeadragonJSPoint"></returns>
    },

    equals: function() {
        /// <summary>Returns true if this rectangle has the same x, y, width and height as the given rectangle.</summary>
        /// <returns type="Boolean"></returns>
    }
}
﻿SeadragonJSSpring = function(initialValue) {
    /// <summary>Creates a spring with the given initial current and target value.</summary>
    /// <param name="initialValue"></param>
    /// <returns type="Object"></returns>
}

SeadragonJSSpring.prototype =
{
    getCurrent: function() {
        /// <summary>Returns the current value of the spring.</summary>
        /// <returns type="Number"></returns>
    },

    getTarget: function() {
        /// <summary>Returns the target value of the spring./summary>
        /// <returns type="Number"></returns>
    },

    resetTo: function(target) {
        /// <summary>Sets both the current and target values of the spring to the given value.</summary>
        /// <param name="target"></param>
    },

    shiftBy: function(delta) {
        /// <summary>Shifts both the current and target values of the spring by the given amount.</summary>
        /// <param name="delta"></param>
    },

    springTo: function(target) {
        /// <summary>Sets the target value of the spring to the given value.</summary>
        /// <param name="target"></param>
    },

    update: function(target) {
        /// <summary>Updates the current value of the spring to move closer towards the target value.</summary>
    }
}
﻿/// <reference name="MicrosoftAjax.js"/>
﻿SeadragonJSRect = function(width, height, tileSize, tileOverlap, minLevel, maxLevel) {
    /// <summary>Creates a TileSource for content of the given width and height, using tiles having the given size and overlap. The minimum and maximum levels for tiles can be supplied, otherwise default values of based on the width and height are used.</summary>
    /// <param name="width"></param>
    /// <param name="height"></param>
    /// <param name="tileSize"></param>
    /// <param name="tileOverlap"></param>
    /// <param name="minLevel"></param>
    /// <param name="maxLevel"></param>
    /// <param name="y"></param>
    /// <field name="aspectRatio" type="Number">The aspect ratio of the content (width/height).</field>
    /// <field name="dimensions" type="SeadragonJSPoint">The natural dimensions of the content (width, height).</field>
    /// <field name="minLevel" type="Number">The minimum level for which tiles exist. The default value is 0.</field>
    /// <field name="maxLevel" type="Number">The maximum level for which tiles exist. The default value is that required to display the content at its natural dimensions.</field>
    /// <field name="tileSize" type="Number">The size of the tiles, in pixels.</field>
    /// <field name="tileOverlap" type="Number">The overlap of the tiles on each edge, in pixels.</field>
    /// <returns type="Object"></returns>
}

SeadragonJSRect.prototype =
{
    aspectRatio: null,
    dimensions: null,
    minLevel: null,
    maxLevel: null,
    tileSize: null,
    tileOverlap: null,

    getLevelScale: function(level) {
        /// <summary>Returns the scale by which all dimensions should be multiplied for the given level. This value increases with the level and is 1 at the default maximum level.</summary>
        /// <param name="level"></param>        
        /// <returns type="Number"></returns>
    },

    getNumTiles: function(level) {
        /// <summary>Returns the number of tiles at the given level in each dimension.</summary>
        /// <param name="level"></param>        
        /// <returns type="Number"></returns>
    },

    getPixelRatio: function(level) {
        /// <summary>Returns the ratio of one pixel to the size of the content at the given level, in both dimensions. For example, at level 0, the ratio is at least 1 in both dimensions, and at the default maximum level, the ratio is exactly the inverse of the content's natural size.</summary>
        /// <param name="level"></param>        
        /// <returns type="Number"></returns>
    },

    getTileAtPoint: function(level, point) {
        /// <summary>Returns the tile at the given level containing the given normalized point. If there is more than one such tile due to tile overlap, returns the most top-left tile.</summary>
        /// <param name="level"></param>        
        /// <returns type="Object"></returns>
    },

    getTileBounds: function(level, x, y) {
        /// <summary>Returns the bounds (position and size) of the given tile in normalized coordinates.</summary>
        /// <param name="level"></param>
        /// <returns type="Object"></returns>
    },

    getTileUrl: function(level, x, y) {
        /// <summary>Returns the URL for the given tile, or null if the URL is not known. Subclasses must override this method.</summary>
        /// <returns type="String"></returns>
    },

    tileExists: function(level, x, y) {
        /// <summary>Returns true if the given tile exists. The default behavior of this method is to simply check that the given tile is within the minimum and maximum levels and the bounds of the given level. Subclasses can override this method for more specific behavior.</summary>
        /// <returns type="Boolean"></returns>
    }
}
﻿SeadragonJSUtils = function() {
    /// <summary>STATIC CLASS</summary>
}

SeadragonJSUtils.getBrowser = function() {
    /// <summary>Returns the user's browser. This method is resistant to user-agent spoofing.</summary>
    /// <returns type="Object"></returns>
}

SeadragonJSUtils.getBrowserVersion = function() {
    /// <summary>Returns the version of the user's browser, or 0 if the browser is unknown. The version is up to one decimal place and does not include any letters (e.g. 'a' for an alpha release).</summary>
    /// <returns type="Number"></returns>
}

SeadragonJSUtils.getElement = function(elmt) {
    /// <summary>Convenience method that returns the HTML Element object for the given argument, which can be the element itself or the element's id.</summary>
    /// <param name="elmt"></param>
    /// <returns type="Object"></returns>
}

SeadragonJSUtils.getElementPosition = function(elmt) {
    /// <summary>Returns the user's browser. This method is resistant to user-agent spoofing.</summary>
    /// <param name="elmt"></param>
    /// <returns type="Object"></returns>
}

SeadragonJSUtils.getElementSize = function(elmt) {
    /// <summary>Returns the size of the given element.</summary>
    /// <param name="elmt"></param>
    /// <returns type="SeadragonJSPoint"></returns>
}

SeadragonJSUtils.getElementStyle = function(elmt) {
    /// <summary>Returns the computed style of the given element. This style object exposes the same Javascript properties as the inline elmt.style object, e.g. "textAlign" for the CSS "text-align" property.</summary>
    /// <param name="elmt"></param>
    /// <returns type="Object"></returns>
}

SeadragonJSUtils.getEvent = function(event) {
    /// <summary>Convenience method that returns the HTML Event object for the given argument, which can be the event itself or undefined, since IE doesn't pass the event object to event handlers.</summary>
    /// <param name="event"></param>
    /// <returns type="Object"></returns>
}

SeadragonJSUtils.getMousePosition = function(event) {
    /// <summary>Returns the position of the mouse during the given event, relative to the document.</summary>
    /// <param name="event"></param>
    /// <returns type="SeadragonJSPoint"></returns>
}

SeadragonJSUtils.getMouseScroll = function(event) {
    /// <summary>Returns the amount the mouse wheel was scrolled during the given event, normalized between -1 and 1.</summary>
    /// <param name="event"></param>
    /// <returns type="Number"></returns>
}

SeadragonJSUtils.getPageScroll = function(event) {
    /// <summary>Returns the amount that the page is currently scrolled.</summary>
    /// <param name="event"></param>
    /// <returns type="Number"></returns>
}

SeadragonJSUtils.getWindowSize = function(event) {
    /// <summary>Returns the current size of the browser's viewport.</summary>
    /// <param name="event"></param>
    /// <returns type="SeadragonJSPoint"></returns>
}

SeadragonJSUtils.imageFormatSupported = function(ext) {
    /// <summary>Returns true if the browser can natively display images of the given format.</summary>
    /// <param name="ext">Extension to check for support</param>
    /// <returns type="Boolean"></returns>
}

SeadragonJSUtils.makeCenteredNode = function(elmt) {
    /// <summary>Returns an HTML element that contains the given HTML node (which can be a text node). The node will be centered both vertically and horizontally when the returned element is placed inside any container. This method ensures vertical centering in IE, whereas the W3C CSS table-cell technique does not.</summary>
    /// <param name="elmt"></param>
    /// <returns type="Object"></returns>
}

SeadragonJSUtils.makeNeutralElement = function(tagName) {
    /// <summary>Creates and returns an HTML element for the given tag name. This element has inline style to neutralize any inherited style.</summary>
    /// <param name="tagName"></param>
    /// <returns type="Object"></returns>
}

SeadragonJSUtils.makeTransparentImage = function(src) {
    /// <summary>Returns an HTML element for the image at the given URL. This element supports alpha channels used by the PNG format safely. This method should be called to ensure transparency in IE6.</summary>
    /// <param name="src"></param>
    /// <returns type="Object"></returns>
}

SeadragonJSUtils.setElementOpacity = function(elmt, opacity, usesAlpha) {
    /// <summary>Sets the opacity of the given element to the given amount, which should be between 0 and 1. Preserves non-alpha filters (e.g. AlphaImageLoader) in IE. If usesAlpha is true, adjusts for browsers which do not handle multi-bit alpha channels properly. If the element is a PNG image that uses an alpha channel, or if the element contains such PNG images, usesAlpha should be true. This is not required for GIF images, which use 1-bit alpha channels.</summary>
    /// <param name="elmt"></param>
    /// <param name="opacity"></param>
    /// <param name="usesAlpha">If usesAlpha is true, adjusts for browsers which do not handle multi-bit alpha channels properly. If the element is a PNG image that uses an alpha channel, or if the element contains such PNG images, usesAlpha should be true. This is not required for GIF images, which use 1-bit alpha channels.</param>
}

SeadragonJSUtils.addEvent = function(elmt, eventName, handler, useCapture) {
    /// <summary>Attaches the given handler function to the given element, for the event with the given name (without the "on" prefix). If useCapture is true and the browser is IE, the element begins capturing all mouse events. If useCapture is true and the browser is not IE, the handler is registered for the event's capture phase instead of the event's bubble phase.</summary>
    /// <param name="elmt"></param>
    /// <param name="eventName"></param>
    /// <param name="handler"></param>
    /// <param name="useCapture">IE's capture model is entirely different from the W3C capture model. Be sure to understand their differences before specifying useCapture to true in cross-browser scripts. As general rules of thumb, only specify it for mouse events, and remove the handlers on or before "mouseup" events. Seadragon.MouseTracker is a good abstraction for this and should be powerful enough for most useCapture scenarios.</param>
}

SeadragonJSUtils.removeEvent = function(elmt, eventName, handler, useCapture) {
    /// <summary>Detaches the given handler function from the given element, for the event with the given name (without the "on" prefix). If useCapture is true and the browser is IE, the element releases capture of mouse events. If useCapture is true and the browser is not IE, the handler for the event's capture phase is removed, instead of for the event's bubble phase.</summary>
    /// <param name="elmt"></param>
    /// <param name="eventName"></param>
    /// <param name="handler"></param>
    /// <param name="useCapture">IE's capture model is entirely different from the W3C capture model. Be sure to understand their differences before specifying useCapture to true in cross-browser scripts. As general rules of thumb, only specify it for mouse events, and remove the handlers on or before "mouseup" events. Seadragon.MouseTracker is a good abstraction for this and should be powerful enough for most useCapture scenarios.</param>
}

SeadragonJSUtils.cancelEvent = function(event) {
    /// <summary>Cancels the given event so that its default action will not be performed by the browser. Note that the event will still continue to propagate up or down the DOM tree unless stopEvent() is called.</summary>
    /// <param name="event"></param>
    /// <returns type="Boolean"></returns>
}

SeadragonJSUtils.stopEvent = function(event) {
    /// <summary>Stops the given event so that it no longer propagates up or down the DOM tree. Note that its default action will still be performed by the browser unless cancelEvent() is called.</summary>
    /// <param name="event"></param>
    /// <returns type="Boolean"></returns>
}

SeadragonJSUtils.createCallback = function(object, func, parameters) {
    /// <summary>Returns a function that calls the given function with the given object as the execution scope. That is, the Javascript keyword this will refer to the given object inside the given function.</summary>
    /// <param name="object"></param>
    /// <param name="func">Function to associate</param>
    /// <param name="parameters" optional="true">Any additional arguments passed to this function will also be passed to the given function, in addition to arguments passed to the returned function. The additional arguments are concatenated to the previous arguments. For example, Seadragon.Utils.createCallback(null, func, 1, 2, 3)(4, 5) is equivalent to func(1, 2, 3, 4, 5).</param>
    /// <returns type="Function"></returns>
}

SeadragonJSUtils.getUrlParameter = function(key) {
    /// <summary>Returns the value for the given key in the URL search string, or null if the URL search string includes no such parameter.</summary>
    /// <param name="key"></param>
    /// <returns type="String"></returns>
}

SeadragonJSUtils.makeAjaxRequest = function(url, callback) {
    /// <summary>Makes an AJAX request to the given URL. If a callback function is given, the request is asynchronous, and the XMLHttpRequest object is passed as the sole parameter to the callback upon completion (readyState of 4). Otherwise, the XML is loaded synchronously and the XMLHttpRequest object is returned by this method. If there is a security error or any other error in simply creating the request, null is passed or returned. Otherwise, the status property of the XMLHttpRequest object can be used to determine success (status of 200 usually means successful).</summary>
    /// <param name="url"></param>
    /// <param name="callback" optional="true"></param>
    /// <returns type="XMLHttpRequest"></returns>
}

SeadragonJSUtils.parseXml = function(string) {
    /// <summary>Parses the given string into an XML document and returns the Document object. This method is synchronous.</summary>
    /// <param name="string"></param>
    /// <returns type="XML Document"></returns>
}

﻿SeadragonJSViewer = function(container) {
    /// <summary>Creates a Seadragon.Viewer inside the given HTML element.</summary>
    /// <param name="container">HTML element that will be injected with the control</param>
    /// <field name="elmt" type="Object">The HTML element containing this viewer and its controls. Note that this is not the same HTML element that is passed into the constructor; the distinction is important for full page mode. The specifics of this element and its children are unspecified and implementation-dependent.</field>
    /// <field name="drawer" type="SeadragonJSDrawer">If content is open, this points to the Seadragon.Drawer instance that renders the content. Otherwise, this is null.</field>
    /// <field name="profiler" type="SeadragonJSProfiler">If content is open, this points to a Seadragon.Profiler instance that is profiling each update. Otherwise, this is null.</field>
    /// <field name="source" type="SeadragonJSTileSource">If content is open, this points to the Seadragon.TileSource instance for the content. Otherwise, this is null.</field>
    /// <field name="viewport" type="SeadragonJSViewport">If content is open, this points to the Seadragon.Viewport instance for the content. Otherwise, this is null.</field>

    /// <returns type="Object"></returns>
}

SeadragonJSRect.prototype =
{
    elmt: null,
    drawer: null,
    profiler: null,
    source: null,
    viewport: null,


    //Content
    isOpen: function() {
        /// <summary>Returns true if content is currently open.</summary>
        /// <returns type="Boolean"></returns>
    },

    openDzi: function(xmlUrl, xmlString) {
        /// <summary>Asynchronously opens the DZI from the XML file at the given URL. If the contents of the XML are also given as a string, the XML is not actually downloaded; otherwise, it is. (The location of the XML is needed in either case to determine the location of the tiles.) Exactly one "open", "error" or "ignore" event is guaranteed to fire upon completion.</summary>
        /// <param name="xmlUrl" type="String"></param>
        /// <param name="xmlString" type="String"></param>
    },

    openTileSource: function(tileSource) {
        /// <summary>Asynchronously opens the given Seadragon.TileSource instance. Exactly one "open", "error", or "ignore" event is guaranteed to fire upon completion.</summary>
        /// <param name="tileSource" type="SeadragonJSTileSource"></param>
    },

    close: function() {
        /// <summary>Close any content.</summary>
    },

    //Controls
    addControl: function(elmt, anchor) {
        /// <summary>Adds the given HTML element as a control to the viewer. The element is optionally anchored to a corner of the container based on the given Seadragon.ControlAnchor value. If no anchor is supplied, or if the anchor is ControlAnchor.NONE, the element is absolutely positioned inside the container.</summary>
        /// <param name="elmt" type="String"></param>
        /// <param name="anchor" type="SeadragonJSControlAnchor" optional="true"></param>
    },

    removeControl: function(elmt) {
        /// <summary>Removes the given control element.</summary>
        /// <param name="elmt" type="String"></param>
    },

    clearControls: function() {
        /// <summary>Remove all controls.</summary>
    },

    getNavControl: function() {
        /// <summary>Returns the <div> element for the default navigation control. The specific buttons in this control are children of this element, e.g. the first child is the zoom in button.</summary>
        /// <returns type="Object"></returns>
    },

    isOpen: function() {
        /// <summary>Returns true if content is currently open.</summary>
        /// <returns type="Boolean"></returns>
    },

    //User Interface
    isDashboardEnabled: function() {
        /// <summary>Returns true if the dashboard is currently enabled. The dashboard includes all of the controls.</summary>
        /// <returns type="Boolean"></returns>

    },

    isFullPage: function() {
        /// <summary>Returns true if the viewport is currently full page.</summary>
        /// <returns type="Boolean"></returns>

    },

    isMouseNavEnabled: function() {
        /// <summary>Returns true if the default mouse navigation is currently enabled.</summary>
        /// <returns type="Boolean"></returns>

    },

    isVisible: function() {
        /// <summary>Returns true if the viewer is currently visible.</summary>
        /// <param name="elmt" type="String"></param>
    },

    setDashboardEnabled: function(visible) {
        /// <summary>Sets whether the dashboard should be enabled. The dashboard includes all of the controls.</summary>
        /// <param name="visible" type="Boolean"></param>
    },

    setFullPage: function(fullPage) {
        /// <summary>Sets whether the viewport should be full page.</summary>
        /// <param name="fullPage" type="Boolean"></param>
    },

    setDashboardEnabled: function(enabled) {
        /// <summary>Sets whether the default mouse navigation should be enabled.</summary>
        /// <param name="visible" type="Boolean"></param>
    },

    setVisible: function(visible) {
        /// <summary>Sets whether the viewer should be visible.</summary>
        /// <param name="visible" type="Boolean"></param>
    },

    //Event handling
    addEventListener: function(eventName, handler) {
        /// <summary>Adds the given handler function as a listener for the event with the given name. This function will receive this Viewer instance as a parameter.</summary>

    },

    removeEventListener: function(eventName, handler) {
        /// <summary>Removes the given handler function as a listener for the event with the given name.</summary>

    }
}
﻿SeadragonJSViewport = function(containerSize, contentSize) {
    /// <summary>Initializes a Viewport inside a container of the given size, for content of the given size. The content will initially be fitted snugly inside the viewport.</summary>
    /// <param name="containerSize" type="SeadragonJSPoint">Size of the container.</param>
    /// <param name="contentSize" type="SeadragonJSPoint">Size of the content.</param>
    /// <returns type="Object"></returns>
}

SeadragonJSRect.prototype =
{
    //Accessors
    getAspectRatio: function() {
        /// <summary>Returns the viewport's aspect ratio (width / height).</summary>
        /// <returns type="Number"></returns>
    },

    getContainerSize: function() {
        /// <summary>Returns the size of the viewport's container, in pixels.</summary>
        /// <returns type="SeadragonJSPoint"></returns>
    },

    getBounds: function(current) {
        /// <summary>Returns the viewport's bounds.</summary>
        /// <param name="current" type="Boolean" optional="true"></param>
        /// <returns type="SeadragonJSRect"></returns>
    },

    getCenter: function(current) {
        /// <summary>Returns the center of the viewport.</summary>
        /// <param name="current" type="Boolean" optional="true"></param>
        /// <returns type="SeadragonJSPoint"></returns>
    },

    getZoom: function(current) {
        /// <summary>Returns the zoom level of the viewport. This zoom level is the ratio of the content's width to the viewport's width, e.g. 1 means the widths are the same, 2 means the content's width is double the viewport's width, etc.</summary>
        /// <param name="current" type="Boolean" optional="true"></param>
        /// <returns type="Number"></returns>
    },

    //Methods
    ensureVisible: function(immediatly) {
        /// <summary>Zooms and pans to ensure that at least some content is ensured to be visible. The amount of the viewport ensured to be filled is defined by Seadragon.Config.visibilityRatio.</summary>
        /// <param name="immediatly" type="Boolean" optional="true"></param>
    },

    fitBounds: function(bounds, immediatly) {
        /// <summary>Zooms and pans so that the given SeadragonJSRect is fitted into the viewport.</summary>
        /// <param name="bounds" type="SeadragonJSRect">Rect to fit.</param>
        /// <param name="immediatly" type="Boolean" optional="true"></param>
    },

    goHome: function(immediatly) {
        /// <summary>Zooms and pans so that the content is fitted snugly into the viewport.</summary>
        /// <param name="immediatly" type="Boolean" optional="true"></param>
    },

    panBy: function(delta, immediatly) {
        /// <summary>Pans the viewport by the given SeadragonJSPoint delta amount.</summary>
        /// <param name="delta" type="SeadragonJSPoint">How to pan by. (Dimensions)</param>
        /// <param name="immediatly" type="Boolean" optional="true"></param>
    },

    panTo: function(center, immediatly) {
        /// <summary>Pans the viewport to the given center point.</summary>
        /// <param name="center" type="SeadragonJSPoint">Point to pan to.</param>
        /// <param name="immediatly" type="Boolean" optional="true"></param>
    },

    zoomBy: function(factor, point, immediately) {
        /// <summary>Zooms by the given factor about the given point, which will remain at the same on-screen location through the zoom. If no point is given, zooms about the viewport center.</summary>
        /// <param name="factor" type="Number">Zoom factor to apply.</param>
        /// <param name="point" type="SeadragonJSPoint" optional="true">Point to set the zoom.</param>
        /// <param name="immediatly" type="Boolean" optional="true"></param>
    },

    zoomTo: function(level, point, immediately) {
        /// <summary>Zooms to the given zoom level about the given point, which will remain at the same on-screen location through the zoom. If no point is given, zooms about the viewport center.</summary>
        /// <param name="factor" type="Number">Zoom level to apply.</param>
        /// <param name="point" type="SeadragonJSPoint" optional="true">Point to set the zoom.</param>
        /// <param name="immediatly" type="Boolean" optional="true"></param>
    },

    resize: function(containerSize, maintain) {
        /// <summary>Resizes the viewport to match the given container size in pixels. If maintain is true, the content's on-screen appearance is maintained relative to the viewport's origin, otherwise the content is resized relative to its center, such that the previously visible content remains visible.</summary>
        /// <param name="containerSize" type="SeadragonJSPoint">Point to pan to.</param>
        /// <param name="maintain" type="Boolean" optional="true"></param>
    },

    update: function() {
        /// <summary>Updates the viewport's current values and returns true if they have changed since the last update.</summary>
        /// <returns type="Boolean"></returns>
    },

    //Conversion Helpers
    deltaPixelsFromPoints: function(deltaPoints, current) {
        /// <summary>Converts the given normalized point delta to an on-screen pixel delta.</summary>
        /// <param name="deltaPoints" type="SeadragonJSPoint"></param>
        /// <param name="current" type="Boolean" optional="true"></param>
        /// <returns type="SeadragonJSPoint"></returns>        
    },

    deltaPointsFromPixels: function(deltaPixels, current) {
        /// <summary>Converts the given on-screen pixel delta to a normalized point delta.</summary>
        /// <param name="deltaPixels" type="SeadragonJSPoint"></param>
        /// <param name="current" type="Boolean" optional="true"></param>
        /// <returns type="SeadragonJSPoint"></returns>        
    },

    pixelFromPoint: function(point, current) {
        /// <summary>Converts the given normalized point to an on-screen pixel, relative to the viewport's container.</summary>
        /// <param name="point" type="SeadragonJSPoint"></param>
        /// <param name="current" type="Boolean" optional="true"></param>
        /// <returns type="SeadragonJSPoint"></returns>        
    },

    pointFromPixel: function(pixel, current) {
        /// <summary>Converts the given on-screen pixel, relative to the viewport's container, to a normalized point.</summary>
        /// <param name="pixel" type="SeadragonJSPoint"></param>
        /// <param name="current" type="Boolean" optional="true"></param>
        /// <returns type="SeadragonJSPoint"></returns>        
    }
}
